#codigo de cabecera --> para ello instalamos geopandas en "open terminal"
import os, geopandas as gpd
# país elegido:
china = gpd.read_file(os.path.join("mapasChina","China_En","China_Pl.shp"))
#polígonos
ciudades = gpd.read_file(os.path.join("mapasChina","China_Cities_Towns","China_Cities_Towns.shp"))
areasUrbanas = gpd.read_file(os.path.join("mapasChina","China_Urban_Areas","China_Urban_Areas.shp"))
cuerposDeAgua = gpd.read_file(os.path.join("mapasChina","China_Water_Bodies","China_Water_Bodies.shp"))
# líneas:
rios = gpd.read_file(os.path.join("mapasChina","China_Hydrography","China_Hydrography.shp"))
ferrocarriles = gpd.read_file(os.path.join("mapasChina","China_Railroads","China_Railroads.shp"))
carreteras = gpd.read_file(os.path.join("mapasChina","China_Roads","China_Roads.shp"))
# para tener en cuenta que estamos haciendo:
# "mapasChina" --> carpeta donde guardamos los archivos .rar y los que descomprimimos
# "China_En" --> nombre de la carpeta descomprimida
# "China_Pl.shp" --> dentro de la carpeta "China_En" está este shapefile
# OJO: la extensión ".shp" es utilizado para almacenar información geográfica y espacial
# verificamos el tipo de dato para la variable "china"
type(china)
geopandas.geodataframe.GeoDataFrame
# verificamos el tipo de dato para la variable "ciudades"
type(ciudades)
geopandas.geodataframe.GeoDataFrame
# verificamos el tipo de dato para la variable "areasUrbanas"
type(areasUrbanas)
geopandas.geodataframe.GeoDataFrame
# verificamos el tipo de dato para la variable "cuerposDeAgua"
type(cuerposDeAgua)
geopandas.geodataframe.GeoDataFrame
# verificamos el tipo de dato para la variable "rios"
type(rios)
geopandas.geodataframe.GeoDataFrame
# verificamos el tipo de dato para la variable "ferrocarriles"
type(ferrocarriles)
geopandas.geodataframe.GeoDataFrame
# verificamos el tipo de dato para la variable "carreteras"
type(carreteras)
geopandas.geodataframe.GeoDataFrame
# dimensiones de "china"
china.shape
# (28, 2) --> tiene 28 filas y 2 columnas
(28, 2)
# names
china.columns
# 'Id' --> identificador único para cada registro de la capa de datos geoespaciales
# 'geometry' --> contiene información geográfica y espacial del país "china", como puntos, líneas o polígonos
Index(['Id', 'geometry'], dtype='object')
# contenido de "china"
china.head()
| Id | geometry | |
|---|---|---|
| 0 | 0 | POLYGON ((123.45705 53.50650, 123.46433 53.498... |
| 1 | 0 | POLYGON ((121.45534 39.64558, 121.46991 39.642... |
| 2 | 0 | POLYGON ((121.37493 31.82396, 121.37503 31.788... |
| 3 | 0 | POLYGON ((121.98422 29.11444, 121.98183 29.105... |
| 4 | 0 | POLYGON ((122.12701 29.78348, 122.13143 29.779... |
# contenido de "ciudades"
ciudades.head()
| NAME | geometry | |
|---|---|---|
| 0 | Wusuli | POINT (123.27793 53.55233) |
| 1 | Mohe | POINT (122.34412 53.47615) |
| 2 | Shang-lao-kou | POINT (122.10260 53.30531) |
| 3 | Xikouzi | POINT (120.65665 53.13139) |
| 4 | Ershiyizhan | POINT (124.92904 52.87976) |
# contenido de "areasUrbanas"
areasUrbanas.head()
| ID | geometry | |
|---|---|---|
| 0 | 1 | POLYGON ((122.35153 53.46278, 122.34337 53.468... |
| 1 | 2 | POLYGON ((123.83556 52.69439, 123.83270 52.702... |
| 2 | 3 | POLYGON ((124.71432 52.32668, 124.69751 52.328... |
| 3 | 4 | POLYGON ((123.66184 52.10870, 123.65645 52.111... |
| 4 | 5 | POLYGON ((124.70179 52.02954, 124.68919 52.029... |
# contenido de "cuerposDeAgua"
cuerposDeAgua.head()
| NAME | geometry | |
|---|---|---|
| 0 | NaN | POLYGON ((98.81810 34.47373, 98.75949 34.45359... |
| 1 | NaN | POLYGON ((102.26344 33.83246, 102.25987 33.831... |
| 2 | Shuoguoke Hu | POLYGON ((100.63714 42.48615, 100.66170 42.479... |
| 3 | Shuobo Hu | POLYGON ((101.28431 42.33086, 101.29453 42.327... |
| 4 | NaN | POLYGON ((128.05568 41.98811, 128.04661 41.988... |
# contenido de "rios"
rios.head()
| NAME | geometry | |
|---|---|---|
| 0 | NaN | LINESTRING (91.38573 29.28649, 91.38492 29.284... |
| 1 | NaN | LINESTRING (124.03345 45.71852, 124.03345 45.7... |
| 2 | NaN | LINESTRING (100.99610 42.42176, 100.98489 42.4... |
| 3 | NaN | LINESTRING (101.23776 42.26225, 101.25378 42.2... |
| 4 | NaN | LINESTRING (128.05348 42.02793, 128.04444 42.0... |
# contenido de "ferrocarriles"
ferrocarriles.head()
| TYPE | geometry | |
|---|---|---|
| 0 | 1 | LINESTRING (123.56954 53.09262, 123.56764 53.0... |
| 1 | 1 | LINESTRING (123.74986 53.04703, 123.75158 53.0... |
| 2 | 1 | LINESTRING (123.51112 52.98682, 123.51725 53.0... |
| 3 | 1 | LINESTRING (123.51112 52.98682, 123.49099 52.9... |
| 4 | 1 | LINESTRING (123.31249 52.89673, 123.33939 52.8... |
# contenido de "carreteras"
carreteras.head()
| TYPE | geometry | |
|---|---|---|
| 0 | 2 | LINESTRING (123.35620 53.44056, 123.35687 53.4... |
| 1 | 2 | LINESTRING (123.35620 53.44056, 123.40727 53.4... |
| 2 | 2 | LINESTRING (124.00000 53.31580, 124.00481 53.3... |
| 3 | 2 | LINESTRING (124.64031 52.97569, 124.64873 52.9... |
| 4 | 8 | LINESTRING (123.87680 52.70866, 123.87283 52.7... |
# tipo de datos de "china"
china.info()
<class 'geopandas.geodataframe.GeoDataFrame'> RangeIndex: 28 entries, 0 to 27 Data columns (total 2 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 Id 28 non-null int64 1 geometry 28 non-null geometry dtypes: geometry(1), int64(1) memory usage: 576.0 bytes
# tipo de datos de "ciudades"
ciudades.info()
<class 'geopandas.geodataframe.GeoDataFrame'> RangeIndex: 5015 entries, 0 to 5014 Data columns (total 2 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 NAME 5015 non-null object 1 geometry 5015 non-null geometry dtypes: geometry(1), object(1) memory usage: 78.5+ KB
# tipo de datos de "areasUrbanas"
areasUrbanas.info()
<class 'geopandas.geodataframe.GeoDataFrame'> RangeIndex: 1514 entries, 0 to 1513 Data columns (total 2 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 ID 1514 non-null int64 1 geometry 1514 non-null geometry dtypes: geometry(1), int64(1) memory usage: 23.8 KB
# tipo de datos de "cuerposDeAgua"
cuerposDeAgua.info()
<class 'geopandas.geodataframe.GeoDataFrame'> RangeIndex: 294 entries, 0 to 293 Data columns (total 2 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 NAME 205 non-null object 1 geometry 294 non-null geometry dtypes: geometry(1), object(1) memory usage: 4.7+ KB
# tipo de datos de "rios"
rios.info()
<class 'geopandas.geodataframe.GeoDataFrame'> RangeIndex: 2328 entries, 0 to 2327 Data columns (total 2 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 NAME 1714 non-null object 1 geometry 2328 non-null geometry dtypes: geometry(1), object(1) memory usage: 36.5+ KB
# tipo de datos de "ferrocarriles"
ferrocarriles.info()
<class 'geopandas.geodataframe.GeoDataFrame'> RangeIndex: 5556 entries, 0 to 5555 Data columns (total 2 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 TYPE 5556 non-null int64 1 geometry 5556 non-null geometry dtypes: geometry(1), int64(1) memory usage: 86.9 KB
# tipo de datos de "carreteras"
carreteras.info()
<class 'geopandas.geodataframe.GeoDataFrame'> RangeIndex: 27256 entries, 0 to 27255 Data columns (total 2 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 TYPE 27256 non-null int64 1 geometry 27256 non-null geometry dtypes: geometry(1), int64(1) memory usage: 426.0 KB
# "folium" --> biblioteca de Python utilizada para crear mapas interactivos y visualizaciones de datos geoespaciales
import folium
# PRIMER PASO --> TRAZADO DE LOS MAPAS BÁSICO
# creamos una visualización gráfica de los datos contenidos en el marco de datos "china"
china.plot()
<Axes: >
# creamos una visualización gráfica de los datos contenidos en el marco de datos "ciudades"
ciudades.plot()
<Axes: >
# creamos una visualización gráfica de los datos contenidos en el marco de datos "areasUrbanas"
areasUrbanas.plot()
<Axes: >
# creamos una visualización gráfica de los datos contenidos en el marco de datos "cuerposDeAgua"
cuerposDeAgua.plot()
<Axes: >
# creamos una visualización gráfica de los datos contenidos en el marco de datos "rios"
rios.plot()
<Axes: >
# creamos una visualización gráfica de los datos contenidos en el marco de datos "ferrocarriles"
ferrocarriles.plot()
<Axes: >
# creamos una visualización gráfica de los datos contenidos en el marco de datos "carreteras"
carreteras.plot()
<Axes: >
# SEGUNDO PASO --> AJUSTES VISUALES PARA LOS POLÍGONOS
china.plot(facecolor="azure", # color del relleno del polígono (parte interna)
edgecolor='black', # color de las líneas
linewidth=0.1) # grosor de las líneas
<Axes: >
ciudades.plot(marker='.', # tipo de marcador
color='red',
markersize=1,
alpha=0.3) # transpariencia
<Axes: >
areasUrbanas.plot(marker='p', # tipo de marcador
color='none',
markersize=10,
edgecolor='black',
linewidth=3,
alpha=1)
<Axes: >
cuerposDeAgua.plot(marker='x', # tipo de marcador circular
color='deeppink',
markersize=7, # aumentar tamaño del marcador
alpha=1) # aumentar la transparencia
<Axes: >
# TERCER PASO --> AJUSTES VISUALES PARA LAS LÍNEAS
rios.plot(edgecolor='blue',
linewidth=1,
linestyle='dotted')
<Axes: >
ferrocarriles.plot(edgecolor='darkorange',
linewidth=1,
linestyle='dotted')
<Axes: >
carreteras.plot(edgecolor='lightgreen',
linewidth=0.7,
linestyle='dotted')
<Axes: >
# verificamos que tengan la misma proyección
# empezamos con "china"
china.crs
<Geographic 2D CRS: EPSG:4326> Name: WGS 84 Axis Info [ellipsoidal]: - Lat[north]: Geodetic latitude (degree) - Lon[east]: Geodetic longitude (degree) Area of Use: - name: World. - bounds: (-180.0, -90.0, 180.0, 90.0) Datum: World Geodetic System 1984 ensemble - Ellipsoid: WGS 84 - Prime Meridian: Greenwich
# seguimos con "ciudades"
ciudades.crs
<Geographic 2D CRS: EPSG:4326> Name: WGS 84 Axis Info [ellipsoidal]: - Lat[north]: Geodetic latitude (degree) - Lon[east]: Geodetic longitude (degree) Area of Use: - name: World. - bounds: (-180.0, -90.0, 180.0, 90.0) Datum: World Geodetic System 1984 ensemble - Ellipsoid: WGS 84 - Prime Meridian: Greenwich
# seguimos con "areasUrbanas"
areasUrbanas.crs
<Geographic 2D CRS: EPSG:4326> Name: WGS 84 Axis Info [ellipsoidal]: - Lat[north]: Geodetic latitude (degree) - Lon[east]: Geodetic longitude (degree) Area of Use: - name: World. - bounds: (-180.0, -90.0, 180.0, 90.0) Datum: World Geodetic System 1984 ensemble - Ellipsoid: WGS 84 - Prime Meridian: Greenwich
# seguimos con "cuerposDeAgua"
cuerposDeAgua.crs
<Geographic 2D CRS: EPSG:4326> Name: WGS 84 Axis Info [ellipsoidal]: - Lat[north]: Geodetic latitude (degree) - Lon[east]: Geodetic longitude (degree) Area of Use: - name: World. - bounds: (-180.0, -90.0, 180.0, 90.0) Datum: World Geodetic System 1984 ensemble - Ellipsoid: WGS 84 - Prime Meridian: Greenwich
# seguimos con "rios"
rios.crs
<Geographic 2D CRS: EPSG:4326> Name: WGS 84 Axis Info [ellipsoidal]: - Lat[north]: Geodetic latitude (degree) - Lon[east]: Geodetic longitude (degree) Area of Use: - name: World. - bounds: (-180.0, -90.0, 180.0, 90.0) Datum: World Geodetic System 1984 ensemble - Ellipsoid: WGS 84 - Prime Meridian: Greenwich
# seguimos con "ferrocarriles"
ferrocarriles.crs
<Geographic 2D CRS: EPSG:4326> Name: WGS 84 Axis Info [ellipsoidal]: - Lat[north]: Geodetic latitude (degree) - Lon[east]: Geodetic longitude (degree) Area of Use: - name: World. - bounds: (-180.0, -90.0, 180.0, 90.0) Datum: World Geodetic System 1984 ensemble - Ellipsoid: WGS 84 - Prime Meridian: Greenwich
# seguimos con "carreteras"
carreteras.crs
<Geographic 2D CRS: EPSG:4326> Name: WGS 84 Axis Info [ellipsoidal]: - Lat[north]: Geodetic latitude (degree) - Lon[east]: Geodetic longitude (degree) Area of Use: - name: World. - bounds: (-180.0, -90.0, 180.0, 90.0) Datum: World Geodetic System 1984 ensemble - Ellipsoid: WGS 84 - Prime Meridian: Greenwich
# como podemos observar manejan la misma salida
# codigo para empezar a suponerponer los mapas
# para los polígonos
ciudades = ciudades.to_crs(china.crs)
areasUrbanas = areasUrbanas.to_crs(china.crs)
cuerposDeAgua = cuerposDeAgua.to_crs(china.crs)
# para las líneas
rios = rios.to_crs(china.crs)
ferrocarriles = ferrocarriles.to_crs(china.crs)
carreteras = carreteras.to_crs(china.crs)
# comenzamos creando la capa en la parte posterior (la base) y agregar capas en la parte superior
# generamos una visualización espacial en la que superponemos tres capas de información geográfica en un mismo gráfico:
# NOTA: el orden de las líneas y polígonos importa ya que si se superponen unos encima de otros,
# el que esté debajo no se mostrará, por tanto: es necesario asegurarse de que todos los elementos
# se superpongan en el orden correcto
# denominamos a nuestra imagen base como "baseMapa"
baseMapa = china.plot(facecolor="azure", edgecolor='black', linewidth=0.1, figsize=(12,12))
# superponemos el polígono más importante y notorio: las "ciudades"
ciudades.plot(marker='.', color='red', markersize=5, alpha=0.5, ax=baseMapa, zorder=3)
# superponemos las líneas: como en el caso de China son muy abundantes, las superponemos de mayor a menor orden
rios.plot(edgecolor='blue', linewidth=0.5, alpha=0.5, ax=baseMapa, zorder=1)
ferrocarriles.plot(edgecolor='darkorange', linewidth=1, alpha=0.5, ax=baseMapa, label='Ferrocarriles', zorder=2)
carreteras.plot(edgecolor='lightgreen', linewidth=1, alpha=0.5, ax=baseMapa, label='Carreteras', zorder=2)
# superponemos los polígonos de "areasUrbanas" y "cuerposDeAgua" al último para que sean visibles, ya que
# en este caso, son muy pocas las áreas urbanas y cuerpos de agua a comparación de los ríos, ferrocarriles y carreteras
areasUrbanas.plot(marker='p', color='none', markersize=10, edgecolor='black', linewidth=4, alpha=1, ax=baseMapa)
cuerposDeAgua.plot(marker='o', color='deeppink', markersize=5, alpha=1, ax=baseMapa, zorder=1)
# agregamos título y leyenda a nuestro mapa del país asiático: "China"
baseMapa.set_title("Mapa de China", fontsize=20)
Text(0.5, 1.0, 'Mapa de China')
# como hemos importado "folium", podemos hacer un mapa interacivo, ya que
# una buena característica sería representar el mapa de forma interactiva:
import folium
m = ciudades.explore(color="red", name="ciudades")
m = rios.explore(m=m, color="blue", name="rios")
m = ferrocarriles.explore(m=m, color="darkorange", name="ferrocarriles")
m = carreteras.explore(m=m, color="lightgreen", name="carreteras")
m = areasUrbanas.explore(m=m, color="black", name="areasUrbanas")
m = cuerposDeAgua.explore(m=m, color="deeppink", name="cuerposDeAgua")
# mapa interactivo que permite al usuario activar y desactivar diferentes capas de información en el mapa
folium.LayerControl().add_to(m)
m